package com.common.app.utls

import android.content.Context
import android.text.*
import android.widget.EditText
import com.common.base.utils.MathUtil
import com.common.base.utils.ToastUtils
import java.util.regex.Pattern

/**
 *
 * 作者：sosou
 *
 * 版本：1.0
 *
 * 创建日期：16/2/2023
 *
 * 描述：
 *
 * 修订历史：
 *
 */
class IntegralInputFilter @JvmOverloads constructor(
    ctx: Context,
    edt: EditText?,
    value: Long,
    toast: String? = null
) :
    InputFilter {
    var mPattern: Pattern

    //输入的最大值
    //    private static final int MAX_VALUE = Integer.MAX_VALUE;
    private var MAX_VALUE: Long = 100000
    private val ctx: Context
    private val maxHint: String?
    private val edt: EditText?

    init {
        mPattern = Pattern.compile("([0-9]|\\.)*")
        MAX_VALUE = value
        this.ctx = ctx
        this.edt = edt
        maxHint = toast
    }

    /**
     * @param source 新输入的字符串
     * @param start  新输入的字符串起始下标，一般为0
     * @param end    新输入的字符串终点下标，一般为source长度-1
     * @param dest   输入之前文本框内容
     * @param dstart 原内容起始坐标，一般为0
     * @param dend   原内容终点坐标，一般为dest长度-1
     * @return 输入内容
     */
    override fun filter(
        source: CharSequence,
        start: Int,
        end: Int,
        dest: Spanned,
        dstart: Int,
        dend: Int
    ): CharSequence {
        val sourceText = source.toString()
        val destText = dest.toString()

        //验证删除等按键
        if (TextUtils.isEmpty(sourceText)) {
            return ""
        }
        val matcher = mPattern.matcher(source)
        //已经输入小数点的情况下，只能输入数字
        if (destText.contains(POINTER)) {
            if (!matcher.matches()) {
                return ""
            } else {
                if (POINTER == source.toString()) {  //只能输入一个小数点
                    return ""
                }
            }

            //验证小数点精度，保证小数点后只能输入两位
            val index = destText.indexOf(POINTER)
            val length = dend - index
            if (length > POINTER_LENGTH) {
                return dest.subSequence(dstart, dend)
            }
        } else {
            /**
             * 没有输入小数点的情况下，只能输入小数点和数字
             * 1. 首位不能输入小数点
             * 2. 如果首位输入0，则接下来只能输入小数点了
             */
            if (!matcher.matches()) {
                return ""
            } else {
                if (POINTER == source.toString() && TextUtils.isEmpty(destText)) {  //首位不能输入小数点
                    return MIM_VALUE.toString()
                }
                if (ZERO == source.toString() && TextUtils.isEmpty(destText)) {  //首位不能输入0
                    return MIM_VALUE.toString()
                }
            }
        }

        //验证输入金额的大小
        val sumText = (destText + sourceText).toDouble()
        if (sumText > MAX_VALUE) {
            if (!TextUtils.isEmpty(maxHint)) {
                ToastUtils.showToast(maxHint)
            } else {
                ToastUtils.showToast("输入值最大为" + MathUtil.retainFormatting(MAX_VALUE.toDouble(), "##0") + "或以内！")
            }
            setCusValue(MathUtil.retainFormatting(MAX_VALUE.toDouble(), "##0"))
            return dest.subSequence(dstart, dend)
        }
        return dest.subSequence(dstart, dend).toString() + sourceText
    }

    private fun setCusValue(mValue: String) {
        if (edt != null) {
            edt.setText(mValue)
            val editable = edt.text
            //新字符串的长度
            val newLen = edt.length()
            //设置新光标所在的位置
            Selection.setSelection(editable, newLen)
        }
    }

    companion object {
        private const val MIM_VALUE = 1

        //小数点后的位数
        private const val POINTER_LENGTH = 2
        private const val POINTER = "."
        private const val ZERO = "0"
    }
}